diff --git a/user_guide/libraries/benchmark.html b/user_guide/libraries/benchmark.html
index 37252b6..17e67fc 100644
--- a/user_guide/libraries/benchmark.html
+++ b/user_guide/libraries/benchmark.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -127,9 +127,9 @@
 <a name="profiler"></a>
 <h2>Profiling Your Benchmark Points</h2>
 
-<p>If you want your benchmark data to be available to the 
-<a href="../general/profiling.html">Profiler</a> all of your marked points must be set up in pairs, and 
-each mark point name must end with <kbd>_start</kbd> and <kbd>_end</kbd>. 
+<p>If you want your benchmark data to be available to the
+<a href="../general/profiling.html">Profiler</a> all of your marked points must be set up in pairs, and
+each mark point name must end with <kbd>_start</kbd> and <kbd>_end</kbd>.
 Each pair of points must otherwise be named identically. Example:</p>
 
 <code>
@@ -158,14 +158,14 @@
 
 <code>&lt;?=$this->benchmark->elapsed_time();?&gt;</code>
 
-<p>You'll notice that it's the same function used in the examples above to calculate the time between two point, except you are 
+<p>You'll notice that it's the same function used in the examples above to calculate the time between two point, except you are
 <strong>not</strong> using any parameters.  When the parameters are absent, Code Igniter does not stop the benchmark until right before the final
 output is sent to the browser.  It doesn't matter where you use the function call, the timer will continue to run until the very end.</p>
 
 <p>An alternate way to show your elapsed time in your view files is to use this pseudo-variable, if you prefer not to use the pure PHP:</p>
 <code>{elapsed_time}</code>
 
-<p class="important"><strong>Note:</strong> If you want to benchmark anything within your controller 
+<p class="important"><strong>Note:</strong> If you want to benchmark anything within your controller
 functions you must set your own start/end points.</p>
 
 <a name="memory"></a>
diff --git a/user_guide/libraries/calendar.html b/user_guide/libraries/calendar.html
index a13cadf..c8a8e80 100644
--- a/user_guide/libraries/calendar.html
+++ b/user_guide/libraries/calendar.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -65,7 +65,7 @@
 
 <h1>Calendaring Class</h1>
 
-<p>The Calendar class enables you to dynamically create calendars. Your calendars can be formatted through the use of a calendar 
+<p>The Calendar class enables you to dynamically create calendars. Your calendars can be formatted through the use of a calendar
 template, allowing 100% control over every aspect of its design. In addition, you can pass data to your calendar cells.</p>
 
 <h2>Initializing the Class</h2>
@@ -112,14 +112,14 @@
 
 <p>Using the above example, day numbers 3, 7, 13, and 26 will become links pointing to the URLs you've provided.</p>
 
-<p class="important"><strong>Note:</strong> By default it is assumed that your array will contain links. 
+<p class="important"><strong>Note:</strong> By default it is assumed that your array will contain links.
 In the section that explains the calendar template below you'll see how you can customize
 how data passed to your cells is handled so you can pass different types of information.</p>
 
 
 <h2>Setting Display Preferences</h2>
 
-<p>There are seven preferences you can set to control various aspects of the calendar.  Preferences are set using an initialization 
+<p>There are seven preferences you can set to control various aspects of the calendar.  Preferences are set using an initialization
 function similar to other classes.  Here is an example:
 
 
diff --git a/user_guide/libraries/config.html b/user_guide/libraries/config.html
index f8a9f52..cd20298 100644
--- a/user_guide/libraries/config.html
+++ b/user_guide/libraries/config.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -75,7 +75,7 @@
 your text editor you'll see that config items are stored in an array called <var>$config</var>.</p>
 
 <p>You can add your own config items to
-this file, or if you prefer to keep your configuration items separate (assuming you even need config items), 
+this file, or if you prefer to keep your configuration items separate (assuming you even need config items),
 simply create your own file and save it in <dfn>config</dfn> folder.</p>
 
 <p><strong>Note:</strong> If you do create your own config files use the same format as the primary one, storing your items in
@@ -84,7 +84,7 @@
 
 <h2>Loading a Config File</h2>
 
-<p><strong>Note:</strong> Code Igniter automatically loads the primary config file (<samp>application/config/config.php</samp>), 
+<p><strong>Note:</strong> Code Igniter automatically loads the primary config file (<samp>application/config/config.php</samp>),
 so you will only need to load a config file if you have created your own.</p>
 
 <p>There are two ways to load a config file:</p>
diff --git a/user_guide/libraries/email.html b/user_guide/libraries/email.html
index ea1b868..b8a68e9 100644
--- a/user_guide/libraries/email.html
+++ b/user_guide/libraries/email.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -218,7 +218,7 @@
 <code>$this->email->set_alt_message('<var>This is the alternative message</var>');</code>
 
 <p>This is an optional message string which can be used if you send HTML formatted email.  It lets you specify an alternative
-message with no HTML formatting which is added to the header string for people who do not accept HTML email.  
+message with no HTML formatting which is added to the header string for people who do not accept HTML email.
 If you do not set your own message Code Igniter will extract the message from your HTML email and strip the tags.</p>
 
 
diff --git a/user_guide/libraries/encryption.html b/user_guide/libraries/encryption.html
index d541174..c80d07d 100644
--- a/user_guide/libraries/encryption.html
+++ b/user_guide/libraries/encryption.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -66,14 +66,14 @@
 <p>The Encryption Class provides two-way data encryption.  It uses a scheme that pre-compiles
 the message using a randomly hashed bitwise XOR encoding scheme, which is then encrypted using
 the Mcrypt library.  If Mcrypt is not available on your server the encoded message will
-still provide a reasonable degree of security for encrypted sessions or other such "light" purposes. 
+still provide a reasonable degree of security for encrypted sessions or other such "light" purposes.
 If Mcrypt is available, you'll effectively end up with a double-encrypted message string, which should
 provide a very high degree of security.</p>
 
 
 <h2>Setting your Key</h2>
 
-<p>A <em>key</em> is a piece of information that controls the cryptographic process and permits an encrypted string to be decoded. 
+<p>A <em>key</em> is a piece of information that controls the cryptographic process and permits an encrypted string to be decoded.
 In fact, the key you chose will provide the <strong>only</strong> means to decode data that was encrypted with that key,
 so not only must you chose the key carefully, you must never change it if you intend use it for persistent data.</p>
 
@@ -82,12 +82,12 @@
 it's impossible to ensure key security so you may want to think carefully before using it for anything
 that requires high security, like storing credit card numbers.</p>
 
-<p>To take maximum advantage of the encryption algorithm, your key should be 32 characters in length (128 bits).  
-The key should be as random a string as you can concoct, with numbers and uppercase and lowercase letters.  
-Your key should <strong>not</strong> be a simple text string. In order to be cryptographically secure it 
+<p>To take maximum advantage of the encryption algorithm, your key should be 32 characters in length (128 bits).
+The key should be as random a string as you can concoct, with numbers and uppercase and lowercase letters.
+Your key should <strong>not</strong> be a simple text string. In order to be cryptographically secure it
 needs to be as random as possible.</p>
 
-<p>Your key can be either stored in your <dfn>application/config/config.php</dfn>, or you can design your own 
+<p>Your key can be either stored in your <dfn>application/config/config.php</dfn>, or you can design your own
 storage mechanism and pass the key dynamically when encoding/decoding.</p>
 
 <p>To save your key to your <dfn>application/config/config.php</dfn>, open the file and set:</p>
@@ -96,7 +96,7 @@
 
 <h2>Message Length</h2>
 
-<p>It's important for you to know that the encoded messages the encryption function generates will be approximately 2.6 times longer than the original 
+<p>It's important for you to know that the encoded messages the encryption function generates will be approximately 2.6 times longer than the original
 message.  For example, if you encrypt the string "my super secret data", which is 21 characters in length, you'll end up
 with an encoded string that is roughly 55 characters (we say "roughly" because the encoded string length increments in
 64 bit clusters, so it's not exactly linear).  Keep this information in mind when selecting your data storage mechanism.  Cookies,
diff --git a/user_guide/libraries/file_uploading.html b/user_guide/libraries/file_uploading.html
index 390b453..730dd05 100644
--- a/user_guide/libraries/file_uploading.html
+++ b/user_guide/libraries/file_uploading.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -63,7 +63,7 @@
 
 <h1>File Uploading Class</h1>
 
-<p>Code Igniter's File Uploading Class permits files to be uploaded.  You can set various 
+<p>Code Igniter's File Uploading Class permits files to be uploaded.  You can set various
 preferences, restricting the type and size of the files.</p>
 
 
@@ -110,7 +110,7 @@
 </body>
 </html></textarea>
 
-<p>You'll notice we are using a form helper to create the opening form tag.  File uploads require a multipart form, so the helper 
+<p>You'll notice we are using a form helper to create the opening form tag.  File uploads require a multipart form, so the helper
 creates the proper syntax for you.  You'll also notice we have an $error variable.  This is so we can show error messages in the event
 the user does something wrong.</p>
 
@@ -165,7 +165,7 @@
 	{
 		$this->load->library('upload');
 	
-		$config['upload_path'] = './uploads/'; 
+		$config['upload_path'] = './uploads/';
 		$config['allowed_types'] = 'gif|jpg|png';
 		$config['max_size']	= '100';
 		$config['max_width']  = '1024';
@@ -202,7 +202,7 @@
 
 <code>www.your-site.com/index.php/<var>upload</var>/</code>
 
-<p>You should see an upload form. Try uploading an image file (either a jpg, gif, or png). If the path in your 
+<p>You should see an upload form. Try uploading an image file (either a jpg, gif, or png). If the path in your
 controller is correct it should work.</p>
 
 
@@ -221,7 +221,7 @@
 
 <h2>Setting Preferences</h2>
 
-<p>Similar to other libraries, you'll control what is allowed to be upload based on your preferences.  In the controller you 
+<p>Similar to other libraries, you'll control what is allowed to be upload based on your preferences.  In the controller you
 built above you set the following preferences:</p>
 
 <code>$config['upload_path'] = './uploads/';<br />
@@ -323,7 +323,7 @@
 
 <h2>$this->upload->do_upload()</h2>
 
-<p>Performs the upload based on the preferences you've set.  Note:  By default the upload routine expects the file to come from a form field 
+<p>Performs the upload based on the preferences you've set.  Note:  By default the upload routine expects the file to come from a form field
 called <dfn>userfile</dfn>, and the form must be a "multipart type:</p>
 
 <code>&lt;form method="post" action="some_action" enctype="multipart/form-data" /></code>
@@ -347,7 +347,7 @@
 
 <h2>$this->upload->data()</h2>
 
-<p>This is a helper function that returns an array containing all of the data related to the file you uploaded. 
+<p>This is a helper function that returns an array containing all of the data related to the file you uploaded.
 Here is the array prototype:</p>
 
 <code>Array<br />
diff --git a/user_guide/libraries/image_lib.html b/user_guide/libraries/image_lib.html
index f2a7a55..c49cad3 100644
--- a/user_guide/libraries/image_lib.html
+++ b/user_guide/libraries/image_lib.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -75,9 +75,9 @@
 
 <p>All three major image libraries are supported:  GD/GD2, NetPBM, and ImageMagick</p>
 
-<p class="important"><strong>Note:</strong> Watermarking is only available using the GD/GD2 library. 
+<p class="important"><strong>Note:</strong> Watermarking is only available using the GD/GD2 library.
 In addition, even though other libraries are supported, GD is required in
-order for the script to calculate the image properties.  The image processing, however, will be performed with the 
+order for the script to calculate the image properties.  The image processing, however, will be performed with the
 library you specify.</p>
 
 
@@ -110,7 +110,7 @@
 
 <p>The above code tells the <dfn>image_resize</dfn> function to look for an image called <em>mypic.jpg</em>
 located in the <dfn>source_image</dfn> folder, then create a thumbnail that is 75 X 50 pixels using the GD2 <dfn>image_library</dfn>.
-Since the <dfn>maintain_ratio</dfn> option is enabled, the thumb will be as close to the target <dfn>width</dfn> and 
+Since the <dfn>maintain_ratio</dfn> option is enabled, the thumb will be as close to the target <dfn>width</dfn> and
 <dfn>height</dfn> as possible while preserving the original aspect ratio.  The thumbnail will be called <em>mypic_thumb.jpg</em>
 </p>
 
@@ -316,7 +316,7 @@
 
 <h2>$this->image_lib->resize()</h2>
 
-<p>The image resizing function lets you resize the original image, create a copy (with or without resizing), 
+<p>The image resizing function lets you resize the original image, create a copy (with or without resizing),
 or create a thumbnail image.</p>
 
 <p>For practical purposes there is no difference between creating a copy and creating
@@ -355,7 +355,7 @@
 
 <h2>$this->image_lib->crop()</h2>
 
-<p>The cropping function works nearly identically to the resizing function except it requires that you set 
+<p>The cropping function works nearly identically to the resizing function except it requires that you set
 preferences for the X and Y axis (in pixels) specifying where to crop, like this:</p>
 
 <code>$config['x_axis'] = '100';<br />
@@ -380,8 +380,8 @@
 }</code>
 
 
-<p>Note: Without a visual interface it is difficult to crop images, so this function is not very useful 
-unless you intend to build such an interface.  That's exactly what we did using for the photo 
+<p>Note: Without a visual interface it is difficult to crop images, so this function is not very useful
+unless you intend to build such an interface.  That's exactly what we did using for the photo
 gallery module in ExpressionEngine, the CMS we develop.  We added a JavaScript UI that lets the cropping
 area be selected.</p>
 
@@ -430,7 +430,7 @@
 
 <ul>
 <li><strong>Text</strong>: The watermark message will be generating using text, either with a True Type font that you specify, or
-using the native text output that the GD library supports. If you use the True Type version your GD installation 
+using the native text output that the GD library supports. If you use the True Type version your GD installation
 must be compiled with True Type support (most are, but not all).</li>
 
 <li><strong>Overlay</strong>: The watermark message will be generated by overlaying an image (usually a transparent PNG or GIF)
diff --git a/user_guide/libraries/input.html b/user_guide/libraries/input.html
index 0ae9566..e531988 100644
--- a/user_guide/libraries/input.html
+++ b/user_guide/libraries/input.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -107,7 +107,7 @@
 
 <code>$data = $this->input->xss_clean($data);</code>
 
-<p>If you want the filter to run automatically every time it encounters POST or COOKIE data you can enable it by opening your 
+<p>If you want the filter to run automatically every time it encounters POST or COOKIE data you can enable it by opening your
 <kbd>application/config/config.php</kbd> file and setting this:
 
 <code>$config['global_xss_filtering'] = TRUE;</code>
@@ -121,7 +121,7 @@
 
 <p>Code Igniter comes with three helper functions that let you fetch POST, COOKIE or SERVER items.  The main advantage of using the provided
 functions rather then fetching an item directly ($_POST['something']) is that the functions will check to see if the item is set and
-return false (boolean) if not.  This lets you conveniently use data without having to test whether an item exists first. 
+return false (boolean) if not.  This lets you conveniently use data without having to test whether an item exists first.
 In other words, normally you might do something like this:
 
 <code>
diff --git a/user_guide/libraries/language.html b/user_guide/libraries/language.html
index 1078653..c407001 100644
--- a/user_guide/libraries/language.html
+++ b/user_guide/libraries/language.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -70,7 +70,7 @@
 
 <p>Language files are typically stored in your <dfn>system/language</dfn> directory.  Alternately you can create a folder called <kbd>language</kbd> inside
 your <kbd>application</kbd> folder and store them there.  Code Igniter will look first in your <dfn>system/application/language</dfn>
-directory.  If the directory does not exist or the specified language is not located there CI will instead look in your global 
+directory.  If the directory does not exist or the specified language is not located there CI will instead look in your global
 <dfn>system/language</dfn> folder.</p>
 
 <p class="important"><strong>Note:</strong>&nbsp; Each language should be stored in its own folder.  For example, the English files are located at:
@@ -87,7 +87,7 @@
 
 <code>$lang['language_key'] = "The actual message to be shown";</code>
 
-<p><strong>Note:</strong> It's a good practice to use a common prefix for all messages in a given file to avoid collisions with 
+<p><strong>Note:</strong> It's a good practice to use a common prefix for all messages in a given file to avoid collisions with
 similarly named items in other files.  For example, if you are creating error messages you might prefix them with <var>error_</var></p>
 
 <code>$lang['<var>error</var>_email_missing'] = "You must submit an email address";<br />
diff --git a/user_guide/libraries/loader.html b/user_guide/libraries/loader.html
index 32bbddf..d213597 100644
--- a/user_guide/libraries/loader.html
+++ b/user_guide/libraries/loader.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -63,7 +63,7 @@
 
 <h1>Loader Class</h1>
 
-<p>Loader, as the name suggests, is used to load elements.  These elements can be libraries (classes) <a href="../general/views.html">View files</a>, 
+<p>Loader, as the name suggests, is used to load elements.  These elements can be libraries (classes) <a href="../general/views.html">View files</a>,
 <a href="../general/helpers.html">Helpers</a>, <a href="../general/plugins.html">Plugins</a>, or your own files.</p>
 
 <p class="important"><strong>Note:</strong> This class is initialized automatically by the system so there is no need to do it manually.</p>
@@ -74,7 +74,7 @@
 
 <h2>$this->load->library('<var>class_name</var>')</h2>
 
-<p>This function is used to load core classes.  Where <var>class_name</var> is the name of the class you want to load. 
+<p>This function is used to load core classes.  Where <var>class_name</var> is the name of the class you want to load.
 Note: We use the terms "class" and "library" interchangeably.</p>
 
 <p>For example, if you would like to send email with Code Igniter, the first step is to load the email class within your controller:</p>
@@ -85,7 +85,7 @@
 
 Each library is described in detail in its own page, so please read the information regarding each one you would like to use.</p>
 
-<p>Parameters can be passed to the library via an array in the second parameter. 
+<p>Parameters can be passed to the library via an array in the second parameter.
 
 
 
@@ -107,7 +107,7 @@
 <p>The first parameter is required.  It is the name of the view file you would like to load.</p>
 
 <p>The second <strong>optional</strong> parameter can take
-an associative array or an object as input, which it runs through the PHP <a href="http://www.php.net/extract">extract</a> function to 
+an associative array or an object as input, which it runs through the PHP <a href="http://www.php.net/extract">extract</a> function to
 convert to variables that can be used in your view files.  Again, read the <a href="../general/views.html">Views</a> page to learn
 how this might be useful.</p>
 
@@ -121,13 +121,13 @@
 
 <h2>$this->load->database('<var>options</var>', <kbd>true/false</kbd>)</h2>
 
-<p>This function lets you load the database class.  The two parameters are <strong>optional</strong>.  Please see the 
+<p>This function lets you load the database class.  The two parameters are <strong>optional</strong>.  Please see the
 <a href="./database/index.html">database</a> section for more info.</p>
 
 
 <h2>$this->load->scaffolding('<var>table_name</var>')</h2>
 
-<p>This function lets you enable scaffolding.  Please see the 
+<p>This function lets you enable scaffolding.  Please see the
 <a href="../general/scaffolding.html">scaffolding</a> section for more info.</p>
 
 
@@ -135,9 +135,9 @@
 <h2>$this->load->vars(<samp>$array</samp>)</h2>
 
 <p>This function takes an associative array as input and generates variables using the PHP <a href="http://www.php.net/extract">extract</a> function.
-This function produces the same result as using the second parameter of the <dfn>$this->load->view()</dfn> function above.  The reason you might 
-want to use this function independently is if you would like to set some global variables in the constructor of your controller 
-and have them become available in any view file loaded from any function.  You can have multiple calls to this function.  The data get cached 
+This function produces the same result as using the second parameter of the <dfn>$this->load->view()</dfn> function above.  The reason you might
+want to use this function independently is if you would like to set some global variables in the constructor of your controller
+and have them become available in any view file loaded from any function.  You can have multiple calls to this function.  The data get cached
 and merged into one array for conversion to variables.
 </p>
 
@@ -150,7 +150,7 @@
 <p>This function loads plugins files, where <var>file_name</var> is the name of the file, without the <kbd>_plugin.php</kbd> extension.</p>
 
 <h2>$this->load->file('<var>filepath/filename</var>', <kbd>true/false</kbd>)</h2>
-<p>This is a generic file loading function.  Supply the filepath and name in the first parameter and it will open and read the file. 
+<p>This is a generic file loading function.  Supply the filepath and name in the first parameter and it will open and read the file.
 By default the data is sent to your browser, just like a View file, but if you set the second parameter to <kbd>true</kbd> (boolean)
 it will instead return the data as a string.</p>
 
diff --git a/user_guide/libraries/output.html b/user_guide/libraries/output.html
index dd3ce42..1fd3554 100644
--- a/user_guide/libraries/output.html
+++ b/user_guide/libraries/output.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -68,9 +68,9 @@
 
 <p class="important"><strong>Note:</strong> This class is initialized automatically by the system so there is no need to do it manually.</p>
 
-<p>Under normal circumstances you won't even notice the Output class since it works transparently without your intervention.  
+<p>Under normal circumstances you won't even notice the Output class since it works transparently without your intervention.
 For example, when you use the <a href="../libraries/loader.html">Loader</a> class to load a view file, it's automatically
-passed to the Output class, which will be called automatically by Code Igniter at the end of system execution. 
+passed to the Output class, which will be called automatically by Code Igniter at the end of system execution.
 It is possible, however, for you to manually intervene with the output if you need to, using either of the two following functions:</p>
 
 <h2>$this->output->set_output();</h2>
diff --git a/user_guide/libraries/pagination.html b/user_guide/libraries/pagination.html
index 317878a..b641e24 100644
--- a/user_guide/libraries/pagination.html
+++ b/user_guide/libraries/pagination.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -86,7 +86,7 @@
 
 <h3>Notes:</h3>
 
-<p>The <var>$config</var> array contains your configuration variables.  It is passed to the <dfn>$this->pagination->initialize</dfn> function as shown above.  Although there are some twenty items you can configure, at 
+<p>The <var>$config</var> array contains your configuration variables.  It is passed to the <dfn>$this->pagination->initialize</dfn> function as shown above.  Although there are some twenty items you can configure, at
 minimum you need the three shown.  Here is a description of what those items represent:</p>
 
 <ul>
@@ -122,7 +122,7 @@
 
 <h4>$config['num_links'] = 2;</h4>
 
-<p>The number of "digit" links you would like before and after the selected page number. For example, the number 2 
+<p>The number of "digit" links you would like before and after the selected page number. For example, the number 2
 will place two digits on either side, as in the example links at the very top of this page.</p>
 
 <h2>Adding Enclosing Markup</h2>
diff --git a/user_guide/libraries/parser.html b/user_guide/libraries/parser.html
index 091817e..febeaa5 100644
--- a/user_guide/libraries/parser.html
+++ b/user_guide/libraries/parser.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -88,7 +88,7 @@
 PHP from your templates (view files).</p>
 
 <p class="important"><strong>Note:</strong> Code Igniter does <strong>not</strong> require you to use this class
-since using pure PHP in your view pages lets them run a little faster.  However, some developers prefer to use a template engine if 
+since using pure PHP in your view pages lets them run a little faster.  However, some developers prefer to use a template engine if
 they work with designers who they feel would find some confusion working with PHP.</p>
 
 <p><strong>Also Note:</strong> The Template Parser Class is <strong>not</strong> not a
@@ -125,7 +125,7 @@
 template would contain two variables: {blog_title} and {blog_heading}</p>
 
 <p>There is no need to "echo" or do something with the data returned by <dfn>$this->parser->parse()</dfn>.  It is automatically
-passed to the output class to be sent to the browser.  However, if you do want the data returned instead of sent to the output class you can 
+passed to the output class to be sent to the browser.  However, if you do want the data returned instead of sent to the output class you can
 pass TRUE (boolean) to the third parameter:</p>
 
 <code>$string = $this->parser->parse('blog_template', $data, TRUE);</code>
@@ -156,7 +156,7 @@
 In a case like this, the entire chunk of data between these pairs would be repeated multiple times, corresponding
 to the number of rows in a result.</p>
 
-<p>Parsing variable pairs is done using the identical code shown above to parse single variables,  
+<p>Parsing variable pairs is done using the identical code shown above to parse single variables,
 except, you will add a multi-dimensional array corresponding to your variable pair data.
 Consider this example:</p>
 
diff --git a/user_guide/libraries/sessions.html b/user_guide/libraries/sessions.html
index e9302d2..5b9d20f 100644
--- a/user_guide/libraries/sessions.html
+++ b/user_guide/libraries/sessions.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -63,9 +63,9 @@
 
 <h1>Session Class</h1>
 
-<p>The Session class permits you maintain a user's "state" and track their activity while they browse your site. 
-The Session class stores session information for each user as serialized (and optionally encrypted) data in a cookie. 
-It can also store the session data in a database table for added security, as this permits the session ID in the 
+<p>The Session class permits you maintain a user's "state" and track their activity while they browse your site.
+The Session class stores session information for each user as serialized (and optionally encrypted) data in a cookie.
+It can also store the session data in a database table for added security, as this permits the session ID in the
 user's cookie to be matched against the stored session ID. By default only the cookie is saved.  If you choose to
 use the database option you'll need to create the session table as indicated below.
 </p>
@@ -75,7 +75,7 @@
 
 <h2>Initializing a Session</h2>
 
-<p>Sessions will typically run globally with each page load, so the session class must either be 
+<p>Sessions will typically run globally with each page load, so the session class must either be
 <a href="../general/libraries.html">initialized</a> in your
 <a href="../general/controllers.html">controller</a> constructors, or it can be
 <a href="../general/autoloader.html">auto-loaded</a> by the system.
@@ -91,8 +91,8 @@
 
 <h2>How do Sessions work?</h2>
 
-<p>When a page is loaded, the session class will check to see if valid session data exists in the user's session cookie. 
-If sessions data does <strong>not</strong> exist (or if it has expired) a new session will be created and saved in the cookie. 
+<p>When a page is loaded, the session class will check to see if valid session data exists in the user's session cookie.
+If sessions data does <strong>not</strong> exist (or if it has expired) a new session will be created and saved in the cookie.
 If a session does exist, its information will be updated and the cookie will be updated.</p>
 
 <p>It's important for you to understand that once initialized, the Session class runs automatically.  There is nothing
@@ -137,7 +137,7 @@
 
 <code>$this->session->userdata('<samp>item</samp>');</code>
 
-<p>Where <samp>item</samp> is the array index corresponding to the item you wish to fetch.  For example, to fetch the session ID you 
+<p>Where <samp>item</samp> is the array index corresponding to the item you wish to fetch.  For example, to fetch the session ID you
 will do this:</p>
 
 <code>$session_id = $this->session->userdata('<samp>session_id</samp>');</code>
@@ -176,13 +176,13 @@
 
 <p>While the session data array stored in the user's cookie contains a Session ID,
 unless you store session data in a database there is no way to validate it.  For some applications that require little or no
-security, session ID validation may not be needed, but if your application requires security, validation is mandatory.</p> 
+security, session ID validation may not be needed, but if your application requires security, validation is mandatory.</p>
 
 <p>When session data is available in a database, every time a valid session is found in the user's cookie, a database
 query is performed to match it.  If the session ID does not match, the session is destroyed.  Session IDs can never
 be updated, they can only be generated when a new session is created.</p>
 
-<p>In order to store sessions, you must first create a database table for this purpose.  Here is the basic 
+<p>In order to store sessions, you must first create a database table for this purpose.  Here is the basic
 prototype (for MySQL) required by the session class:</p>
 
 <textarea class="textarea" style="width:100%" cols="50" rows="8">
@@ -232,7 +232,7 @@
 <td class="td"><strong>sess_expiration</strong></td>
 <td class="td">7200</td>
 <td class="td">None</td>
-<td class="td">The number of seconds you would like the session to last. The default value is 2 hours (7200 seconds). 
+<td class="td">The number of seconds you would like the session to last. The default value is 2 hours (7200 seconds).
 If you would like a non-expiring session set the value to zero: 0</td>
 
 
diff --git a/user_guide/libraries/table.html b/user_guide/libraries/table.html
index 10bb4b3..d41cc88 100644
--- a/user_guide/libraries/table.html
+++ b/user_guide/libraries/table.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -75,8 +75,8 @@
 
 <h2>Examples</h2>
 
-<p>Here is an example showing how you can create a table from a multi-dimensional array. 
-Note that the first array index will become the table heading (or you can set your own headings using the 
+<p>Here is an example showing how you can create a table from a multi-dimensional array.
+Note that the first array index will become the table heading (or you can set your own headings using the
 <dfn>set_heading()</dfn> function described in the function reference below).</p>
 
 <code>
@@ -92,7 +92,7 @@
 echo $this->table->generate($data);		
 </code>
 
-<p>Here is an example of a table created from a database query result. The table class will automatically generate the 
+<p>Here is an example of a table created from a database query result. The table class will automatically generate the
 headings based on the table names (or you can set your own headings using the <dfn>set_heading()</dfn> function described
 in the function reference below).</p>
 
@@ -165,7 +165,7 @@
 $this->table->set_template($tmpl);
 </code>
 
-<p class="important"><strong>Note:</strong>&nbsp; You'll notice there are two sets of "row" blocks in the template.  These permit you to create alternating row colors or design elements that alternate with each 
+<p class="important"><strong>Note:</strong>&nbsp; You'll notice there are two sets of "row" blocks in the template.  These permit you to create alternating row colors or design elements that alternate with each
 iteration of the row data.</p>
 
 <p>You are NOT required to submit a complete template.  If you only need to change parts of the layout you can simply submit those elements.
diff --git a/user_guide/libraries/trackback.html b/user_guide/libraries/trackback.html
index ff71ea9..d3357be 100644
--- a/user_guide/libraries/trackback.html
+++ b/user_guide/libraries/trackback.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -123,7 +123,7 @@
 <p>Receiving Trackbacks is a little more complex than sending them, only because you will need a database table in which to store them,
 and you will need to validate the incoming trackback data.  You are encouraged to implement a thorough validation process to
 guard against spam and duplicate data.  You may also want to limit the number of Trackbacks you allow from a particular IP within
-a given span of time to further curtail spam.  The process of receiving a Trackback is quite simple; 
+a given span of time to further curtail spam.  The process of receiving a Trackback is quite simple;
 the validation is what takes most of the effort.</p>
 
 <h2>Your Ping URL</h2>
@@ -132,7 +132,7 @@
 that people will use to send you Trackbacks (we will refer to this as your "Ping URL").</p>
 
 <p>Your Ping URL must point to a controller function where your Trackback receiving code is located, and the URL
-must contain the ID number for each particular entry, so that when the Trackback is received you'll be 
+must contain the ID number for each particular entry, so that when the Trackback is received you'll be
 able to associate it with a particular entry.</p>
 
 <p>For example, if your controller class is called <dfn>Trackback</dfn>, and the receiving function is called <dfn>receive</dfn>, your
diff --git a/user_guide/libraries/unit_testing.html b/user_guide/libraries/unit_testing.html
index f0b3782..02229e5 100644
--- a/user_guide/libraries/unit_testing.html
+++ b/user_guide/libraries/unit_testing.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -66,8 +66,8 @@
 <p>Unit testing is an approach to software development in which tests are written for each function in your application.
 If you are not familiar with the concept you might do a little googling on the subject.</p>
 
-<p>Code Igniter's Unit Test class is quite simple, consisting of an evaluation function and two result functions. 
-It's not intended to be a full-blown test suite but rather a simple mechanism to evaluate your code 
+<p>Code Igniter's Unit Test class is quite simple, consisting of an evaluation function and two result functions.
+It's not intended to be a full-blown test suite but rather a simple mechanism to evaluate your code
 to determine if it is producing the correct data type and result.
 </p>
 
@@ -86,7 +86,7 @@
 
 <h2>$this->unit->run( <var>test</var>, <var>expected result</var>, '<var>test name</var>' );</h2>
 
-<p>Where <var>test</var> is the result of the code you wish to test, 
+<p>Where <var>test</var> is the result of the code you wish to test,
 <var>expected result</var> is the data type you expect, and <var>test name</var> is an optional name you can give your test. Example:</p>
 
 <code>$test = 1 + 1;<br />
@@ -105,7 +105,7 @@
 
 <code>$this->unit->run('Foo', 'is_string');</code>
 
-<p>Notice the use of "is_string" in the second parameter?  This tells the function to evaluate whether your test is producing a string 
+<p>Notice the use of "is_string" in the second parameter?  This tells the function to evaluate whether your test is producing a string
 as the result.  Here is a list of allowed comparison types:</p>
 
 <ul>
@@ -124,7 +124,7 @@
 
 <h2>Generating Reports</h2>
 
-<p>You can either display results after each test, or your can run several tests and generate a report at the end. 
+<p>You can either display results after each test, or your can run several tests and generate a report at the end.
 To show a report directly simply echo or return the <var>run</var> function:</p>
 
 <code>echo $this->unit->run($test, $expected_result);</code>
diff --git a/user_guide/libraries/uri.html b/user_guide/libraries/uri.html
index 9218c0d..367e1b7 100644
--- a/user_guide/libraries/uri.html
+++ b/user_guide/libraries/uri.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -70,7 +70,7 @@
 
 <h2>$this->uri->segment(<var>n</var>)</h2>
 
-<p>Permits you to retrieve a specific segment. Where <var>n</var> is the segment number you wish to retrieve.  
+<p>Permits you to retrieve a specific segment. Where <var>n</var> is the segment number you wish to retrieve.
 Segments are numbered from left to right. For example, if your full URL is this:</p>
 
 <code>http://www.your-site.com/index.php/news/local/metro/crime_is_up</code>
@@ -84,7 +84,7 @@
 <li>crime_is_up</li>
 </ol>
 
-<p>By default the function returns FALSE (boolean) if the segment does not exist. There is an optional second parameter that 
+<p>By default the function returns FALSE (boolean) if the segment does not exist. There is an optional second parameter that
 permits you to set your own default value if the segment is missing.
 For example, this would tell the function to return the number zero in the event of failure:</p>
 
diff --git a/user_guide/libraries/user_agent.html b/user_guide/libraries/user_agent.html
index 6028f79..8640320 100644
--- a/user_guide/libraries/user_agent.html
+++ b/user_guide/libraries/user_agent.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -126,7 +126,7 @@
 <p>Returns TRUE/FALSE (boolean) if the user agent is a known robot.</p>
 
 <p class="important"><strong>Note:</strong>&nbsp; The user agent library only contains the most common robot
-definitions.  It is not a complete list of bots. There are hundreds of them so searching for each one would not be 
+definitions.  It is not a complete list of bots. There are hundreds of them so searching for each one would not be
 very efficient. If you find that some bots that commonly visit your site are missing from the list you can add them to your
 <dfn>application/config/user_agents.php</dfn> file.</p>
 
diff --git a/user_guide/libraries/validation.html b/user_guide/libraries/validation.html
index 0a4905a..aaf416d 100644
--- a/user_guide/libraries/validation.html
+++ b/user_guide/libraries/validation.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -75,8 +75,8 @@
 
 <ol>
 <li>Check for required data.</li>
-<li>Verify that the data is of the correct type, and meets the correct criteria. (For example, if a username is submitted 
-it must be validated to contain only permitted characters.  It must be of a minimum length, 
+<li>Verify that the data is of the correct type, and meets the correct criteria. (For example, if a username is submitted
+it must be validated to contain only permitted characters.  It must be of a minimum length,
 and not exceed a maximum length. The username can't be someone else's existing username, or perhaps even a reserved word. Etc.)
 <li>Sanitize the data for security.</li>
 <li>Pre-format the data if needed (Does the data need to be trimmed?  HTML encoded?  Etc.)</li>
@@ -195,7 +195,7 @@
 
 <code>www.your-site.com/index.php/<var>form</var>/</code>
 
-<p><strong>If you submit the form you should simply see the form reload.  That's because you haven't set up any validation 
+<p><strong>If you submit the form you should simply see the form reload.  That's because you haven't set up any validation
 rules yet, which we'll get to in a moment.</strong></p>
 
 
@@ -219,8 +219,8 @@
 </ol>
 
 <p>The <dfn>controller</dfn> (form.php) has one function: <dfn>index()</dfn>. This function initializes the validation class and
-loads the <var>form helper</var> and <var>URL helper</var> used by your view files. It also <samp>runs</samp> 
-the validation routine. Based on 
+loads the <var>form helper</var> and <var>URL helper</var> used by your view files. It also <samp>runs</samp>
+the validation routine. Based on
 whether the validation was successful it either presents the form or the success page.</p>
 
 <p><strong>Since you haven't told the validation class to validate anything yet, it returns "false" (boolean false) by default.  The <samp>run()</samp>
@@ -313,7 +313,7 @@
 
 <h2>Prepping Data</h2>
 
-<p>In addition to the validation functions like the ones we used above, you can also prep your data in various ways.  
+<p>In addition to the validation functions like the ones we used above, you can also prep your data in various ways.
 For example, you can set up rules like this:
 
 <code>$rules['username']	= "<kbd>trim</kbd>|required|min_length[5]|max_length[12]|<kbd>xss_clean</kbd>";<br />
@@ -391,17 +391,17 @@
 
 <p><strong>To invoke a callback just put the function name in a rule, with "callback_" as the rule prefix.</strong></p>
 
-<p>The error message was set using the <dfn>$this->validation->set_message</dfn> function. 
+<p>The error message was set using the <dfn>$this->validation->set_message</dfn> function.
 Just remember that the message key (the first parameter) must match your function name.</p>
 
-<p class="important"><strong>Note:</strong> You can apply your own custom error messages to any rule, just by setting the 
+<p class="important"><strong>Note:</strong> You can apply your own custom error messages to any rule, just by setting the
 message similarly. For example, to change the message for the "required" rule you will do this:</p>
 
 <code>$this->validation->set_message('required', 'Your custom message here');</code>
 
 <h2>Re-populating the form</h2>
 
-<p>Thus far we have only been dealing with errors.  It's time to repopulate the form field with the submitted data. 
+<p>Thus far we have only been dealing with errors.  It's time to repopulate the form field with the submitted data.
 This is done similarly to your rules.  Add the following code to your controller, just below your rules:</p>
 
 <code>$fields['username'] = 'Username';<br />
@@ -411,7 +411,7 @@
 <br />
 $this->validation->set_fields($fields);</code>
 
-<p>The array keys are the actual names of the form fields, the value represents the full name that you want shown in the 
+<p>The array keys are the actual names of the form fields, the value represents the full name that you want shown in the
 error message.</p>
 
 <p>The index function of your controller should now look like this:</p>
@@ -512,7 +512,7 @@
 have set (&lt;p> tags by default).</p>
 
 <p class="important"><strong>Note: </strong>To display errors this way you must remember to set your fields using the <kbd>$this->validation->set_fields</kbd>
-function described earlier. The errors will be turned into variables that have "_error" after your field name. 
+function described earlier. The errors will be turned into variables that have "_error" after your field name.
 For example, your "username" error will be available at:<br /><dfn>$this->validation->username_error</dfn>.</p>
 
 
@@ -666,7 +666,7 @@
 
 <h2>Dealing with Select Menus, Radio Buttons, and Checkboxes</h2>
 
-<p>If you use select menus, radio buttons or checkboxes, you will want the state of 
+<p>If you use select menus, radio buttons or checkboxes, you will want the state of
 these items to be retained in the event of an error.  The Validation class has three functions that help you do this:</p>
 
 <h2>set_select()</h2>
diff --git a/user_guide/libraries/xmlrpc.html b/user_guide/libraries/xmlrpc.html
index 7cd00a2..d768659 100644
--- a/user_guide/libraries/xmlrpc.html
+++ b/user_guide/libraries/xmlrpc.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -64,18 +64,18 @@
 <h1>XML-RPC and XML-RPC Server Classes</h1>
 
 
-<p>Code Igniter's XML-RPC classes permit you to send requests to another server, or set up 
+<p>Code Igniter's XML-RPC classes permit you to send requests to another server, or set up
 your own XML-RPC server to receive requests.</p>
 
 
 <h2>What is XML-RPC?</h2>
 
-<p>Quite simply it is a way for two computers to communicate over the internet using XML.  
-One computer, which we will call the <dfn>client</dfn>, sends an XML-RPC <strong>request</strong> to 
+<p>Quite simply it is a way for two computers to communicate over the internet using XML.
+One computer, which we will call the <dfn>client</dfn>, sends an XML-RPC <strong>request</strong> to
 another computer, which we will call the <dfn>server</dfn>.  Once the server receives and processes the request it
 will send back a <strong>response</strong> to the client.</p>
 
-<p>For example, using the MetaWeblog API, an XML-RPC Client (usually a desktop publishing tool) will 
+<p>For example, using the MetaWeblog API, an XML-RPC Client (usually a desktop publishing tool) will
 send a request to an XML-RPC Server running on your site.  This request might be a new weblog entry
 being sent for publication, or it could be a request for an existing entry for editing.
 
@@ -141,12 +141,12 @@
 
 <h2>Anatomy of a Request</h2>
 
-<p>An XML-RPC <dfn>request</dfn> is simply the data you are sending to the XML-RPC server.  Each piece of data in a request 
-is referred to as a <dfn>request parameter</dfn>.  The above example has two parameters: 
+<p>An XML-RPC <dfn>request</dfn> is simply the data you are sending to the XML-RPC server.  Each piece of data in a request
+is referred to as a <dfn>request parameter</dfn>.  The above example has two parameters:
 The URL and title of your site. When the XML-RPC server receives your request, it will look for parameters it requires.</p>
 
 <p>Request parameters must be placed into an array for transportation, and each parameter can be one
-of seven data types (strings, numbers, dates, etc.). If your parameters are something other than strings 
+of seven data types (strings, numbers, dates, etc.). If your parameters are something other than strings
 you will have to include the data type in the request array.</p>
 
 <p>Here is an example of a simple array with three parameters:</p>
@@ -173,10 +173,10 @@
 
 <h2>Creating an XML-RPC Server</h2>
 
-<p>An XML-RPC Server acts as a traffic cop of sorts, waiting for incoming requests and redirecting them to the 
+<p>An XML-RPC Server acts as a traffic cop of sorts, waiting for incoming requests and redirecting them to the
 appropriate functions for processing.</p>
 
-<p>To create your own XML-RPC server involves initializing the XML-RPC Server class in your controller where you expect the incoming 
+<p>To create your own XML-RPC server involves initializing the XML-RPC Server class in your controller where you expect the incoming
 request to appear, then setting up an array with mapping instructions so that incoming requests can be sent to the appropriate
 class and method for processing.</p>
 
@@ -192,15 +192,15 @@
 $this->xmlrpcs->initialize($config);<br />
 $this->xmlrpcs->serve();</code>
 
-<p>The above example contains an array specifying two method requests that the Server allows.  
+<p>The above example contains an array specifying two method requests that the Server allows.
 The allowed methods are on the left side of the array. When either of those are received, they will be mapped to the class and method on the right.
 
-<p>In other words, if an XML-RPC Client sends a request for the <var>new_post</var> method, your 
+<p>In other words, if an XML-RPC Client sends a request for the <var>new_post</var> method, your
 server will load the <dfn>My_blog</dfn> class and call the <dfn>new_entry</dfn> function.
-If the request is for the <var>update_post</var> method, your 
+If the request is for the <var>update_post</var> method, your
 server will load the <dfn>My_blog</dfn> class and call the <dfn>update_entry</dfn> function.</p>
 
-<p>The function names in the above example are arbitrary.  You'll decide what they should be called on your server, 
+<p>The function names in the above example are arbitrary.  You'll decide what they should be called on your server,
 or if you are using standardized APIs, like the Blogger or MetaWeblog API, you'll use their function names.</p>
 
 
@@ -225,7 +225,7 @@
 Using this object you will have access to the <em>request parameters</em> enabling you to process the request.  When
 you are done you will send a <dfn>Response</dfn> back to the Client.<p>
 
-<p>Below is a real-world example, using the Blogger API.  One of the methods in the Blogger API is <dfn>getUserInfo()</dfn>.  
+<p>Below is a real-world example, using the Blogger API.  One of the methods in the Blogger API is <dfn>getUserInfo()</dfn>.
 Using this method, an XML-RPC Client can send the Server a username and password, in return the Server sends
 back information about that particular user (nickname, user ID, email address, etc.).  Here is how the processing
 function might look:</p>
@@ -279,7 +279,7 @@
 
 <code>$request = array('Response data',  'array');</code>
 
-<p>Responses, however, usually contain multiple pieces of information. In order to accomplish this we must put the response into its own 
+<p>Responses, however, usually contain multiple pieces of information. In order to accomplish this we must put the response into its own
 array so that the primary array continues to contain a single piece of data.  Here's an example showing how this might be accomplished:</p>
 
 <code>
@@ -314,12 +314,12 @@
 
 <h2>Creating Your Own Client and Server</h2>
 
-<p>To help you understand everything we've covered thus far, let's create a couple controllers that act as 
+<p>To help you understand everything we've covered thus far, let's create a couple controllers that act as
 XML-RPC Client and Server.  You'll use the Client to send a request to the Server and receive a response.</p>
 
 <h3>The Client</h3>
 
-<p>Using a text editor, create a controller called <dfn>xmlrpc_client.php</dfn>.  
+<p>Using a text editor, create a controller called <dfn>xmlrpc_client.php</dfn>.
 In it, place this code and save it to your <samp>applications/controllers/</samp> folder:</p>
 
 <textarea class="textarea" style="width:100%" cols="50" rows="32"><?php
@@ -357,7 +357,7 @@
 
 <h3>The Server</h3>
 
-<p>Using a text editor, create a controller called <dfn>xmlrpc_server.php</dfn>.  
+<p>Using a text editor, create a controller called <dfn>xmlrpc_server.php</dfn>.
 In it, place this code and save it to your <samp>applications/controllers/</samp> folder:</p>
 
 <textarea class="textarea" style="width:100%" cols="50" rows="30"><?php
@@ -386,7 +386,7 @@
 									'you_said'  => $parameters['0'],
 									'i_respond' => 'Not bad at all.'),
 							'struct');
-						 
+						
 		return $this->xmlrpc->send_response($response);
 	}
 }
@@ -442,7 +442,7 @@
 <code>$this->xmlrpc->display_response();</code>
 
 <h2>$this->xmlrpc->send_error_message()</h2>
-<p>This function lets you send an error message from your server to the client. First parameter is the error number while the second parameter 
+<p>This function lets you send an error message from your server to the client. First parameter is the error number while the second parameter
 is the error message.</p>
 <code>return $this->xmlrpc->send_error_message('123', 'Requested data not available');</code>
 
diff --git a/user_guide/libraries/zip.html b/user_guide/libraries/zip.html
index c03b54f..6f0a38f 100644
--- a/user_guide/libraries/zip.html
+++ b/user_guide/libraries/zip.html
@@ -12,7 +12,7 @@
 <script type="text/javascript" src="../nav/moo.fx.js"></script>
 <script type="text/javascript">
 window.onload = function() {
-	myHeight = new fx.Height('nav', {duration: 400}); 
+	myHeight = new fx.Height('nav', {duration: 400});
 	myHeight.hide();
 }
 </script>
@@ -62,7 +62,7 @@
 
 
 <h1>Zip Encoding Class</h1>
-<p>Code Igniter's Zip Encoding Class classes permit you to create Zip archives. Archives can be downloaded to your 
+<p>Code Igniter's Zip Encoding Class classes permit you to create Zip archives. Archives can be downloaded to your
 desktop or saved to a directory.</p>
 
 
@@ -116,7 +116,7 @@
 </code>
 
 
-<p>You are allowed to have multiple calls to this function in order to 
+<p>You are allowed to have multiple calls to this function in order to
 add several files to your archive.  Example:</p>
 
 <code>
